#include "Punto.h"
#include <iostream>
#include <Math.h> 

short int Punto::VELOCIDAD_MAXIMA = 10 ;

void Punto::actualizarVelocidadRestante(){
	this->velocidadRestante = this->velocidadRestante - this->factorVelocidad ;
}

bool Punto::deboMoverme(){
	if(this->velocidadRestante <= 0){
		this->velocidadRestante = VELOCIDAD_MAXIMA ;
		return true;

	}else{
		return false;
	}
}

bool Punto::coordenadasIguales(Punto* otroPunto){
	return ( (this->getX() == otroPunto->getX()) && (this->getY() == otroPunto->getY()) );
}

void Punto::iniciarVelocidad(){
	this->velocidadRestante = Punto::VELOCIDAD_MAXIMA;
    // la velocidad por default es la menor 
	this->factorVelocidad = 10 /*Poner en 1*/ ;
}

	
Punto::Punto(){
	this->x = 0;
	this->y = 0;
}

Punto::Punto(unsigned short int x, unsigned short int y){
		this->iniciarVelocidad();
		this->x = x;
		this->y = y;
}

Punto::Punto(Punto* punto){
	this->iniciarVelocidad();
	this->x = punto->getX();
	this->y = punto->getY();
	this->factorVelocidad = punto->getFactorVelocidad();
	this->velocidadRestante = punto->getVelocidadRestante();
}

void Punto::setFactorVelocidad(short int unFactorVelocidad){
	if (unFactorVelocidad <= Punto::VELOCIDAD_MAXIMA ){
		this->factorVelocidad = unFactorVelocidad;
	}else{
		this->factorVelocidad = Punto::VELOCIDAD_MAXIMA;
	}
}

void Punto::setVelocidadRestante(short int unaVelocidadRestante){
	this->velocidadRestante = unaVelocidadRestante;
}

short int Punto::getFactorVelocidad(){
	return this->factorVelocidad ;
}

short int Punto::getVelocidadRestante(){
	return this->velocidadRestante ;
}

bool Punto::operator==(const Punto& punto){
	return ((this->x == punto.x) && (this->y == punto.y));
}

float Punto::distanciaCon(Punto* punto){
	float aux1 = (float)((this->x - punto->getX())*(this->x - punto->getX()));
	float aux2 = (float)((this->y - punto->getY())*(this->y - punto->getY()));
	return (sqrt(aux1 + aux2));
}

Punto::~Punto(){
	}

// Comentado lo de velocidad ya que se manejo de otra manera.
void Punto::incrementarX(){
    //actualizarVelocidadRestante();
	//if(this->deboMoverme()){
		this->x++ ;	
	//}
}

void Punto::incrementarY(){
    //actualizarVelocidadRestante();
	//if(this->deboMoverme()){
		this->y++ ;	
	//}
}

void Punto::decrementarX(){
    //actualizarVelocidadRestante();
	//if(this->deboMoverme()){
		this->x--;	
	//}
}

void Punto::decrementarY(){
    //actualizarVelocidadRestante();
	//if(this->deboMoverme()){
		this->y--;	
	//}
}

short int Punto::getDesplazamientoX(Punto *otroPunto){

	short int dist = this->getX() - otroPunto->getX();
	dist = abs(dist);
	return dist;
}

short int Punto::getDesplazamientoY(Punto *otroPunto){

	short int dist = this->getY() - otroPunto->getY();
	dist = abs(dist);
	return dist;
}

float Punto::getDistancia(Punto *otroPunto){
	
	short int despX = this->getDesplazamientoX(otroPunto);
	short int despY = this->getDesplazamientoY(otroPunto);
	float dist = (float)(despX*despX + despY*despY);
	dist = sqrt(dist);
	return dist;
}

void Punto::copiarValores(Punto *otroPunto){
	this->x = otroPunto->getX();
	this->y = otroPunto->getY();
}

unsigned short int Punto::getX(){ 
	return this->x;
}

unsigned short int Punto::getY(){ 
	return this->y;
}

void Punto::setX(unsigned short  int nuevoX){ 
	this->x = nuevoX;
}
void Punto::setY(unsigned short int nuevoY){ 
	this->y = nuevoY;
}

bool Punto::equals(Punto* punto){
	return ( (this->getX()== punto->getX()) && (this->getY()== punto->getY()));
}
